home *** CD-ROM | disk | FTP | other *** search
/ World of Sound / World of Sound.iso / utils / miditools / obersuite-1.03 / sourcecode / tofile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-01-23  |  3.8 KB  |  168 lines
  1. /**************************************************************************
  2. * tofile.c:    Functions for storing patch data in a disk file.
  3. *        A part of OberSuite for the Commodore Amiga.
  4. *
  5. * Author:    Daniel Barrett, barrett@cs.umass.edu.
  6. * Version:    1.0.
  7. * Copyright:    None!  This program is in the Public Domain.
  8. *        Please share it with others.
  9. ***************************************************************************/
  10.  
  11. #include "decl.h"
  12.  
  13. /*
  14.  * Write patch data from the PATCHINFO structure into the named file.
  15.  * Return TRUE if successful, or FALSE if not.
  16.  * Possible things that can go wrong:
  17.  *
  18.  *    OpenWriteFile() might be unable to open the file.
  19.  *    The user could press ^C.
  20.  *    write() might not write the correct number of bytes to the file.
  21.  *     (Correct number == (number of patches) * (size of 1 patch))
  22.  */
  23.  
  24. BOOL PutPatchToFile(PATCHINFO *pi, char *filename)
  25. {
  26.     int fd = 0;
  27.     long written, shouldWrite;
  28.  
  29.     if (fd = OpenWriteFile(filename))
  30.     {
  31.         if (CtrlcCheck())
  32.         {
  33.             close(fd);
  34.             ErrorMsg(ERROR_CTRLC);
  35.             return(FALSE);
  36.         }
  37.  
  38.         shouldWrite = pi->numPatches * pi->rightSize;
  39.         written = write(fd, pi->data, shouldWrite);
  40.  
  41.         if (written != shouldWrite)
  42.             ErrorMsg(ERROR_WRITEFILE);
  43.  
  44.         close(fd);
  45.         return(written == shouldWrite);
  46.     }
  47.     else
  48.         return(FALSE);
  49. }
  50.  
  51.  
  52. /*
  53.  * Open a file for writing.
  54.  */
  55.  
  56. int OpenWriteFile(char *filename)
  57. {
  58.     int fd=NULL;
  59.  
  60.     if ((fd = open(filename, O_WRONLY+O_CREAT+O_TRUNC)) == -1)
  61.     {
  62.         if (ERR_OUTPUT_ALLOWED)
  63.             fprintf(stderr, "%s: ", filename);
  64.         ErrorMsg(ERROR_CREATEFILE);
  65.         return(NULL);
  66.     }
  67.     else
  68.         return(fd);
  69. }
  70.  
  71.  
  72. /*
  73.  * If the named file already exists, ask the user whether or not it should
  74.  *  be overwritten.  The first character of the user's response is converted
  75.  *  to upper case.  User responses have the following effects:
  76.  *
  77.  *    RESPONSE    MEANING        EFFECT
  78.  *    -------------------------------------------------------------------
  79.  *    Y        Yes        It is OK to overwrite the file.
  80.  *                    Return FALSE.
  81.  *
  82.  *    A        All        It is OK to overwrite the file.
  83.  *                    Return FALSE, and cause
  84.  *                     all subsequent calls of this
  85.  *                     function automatically to return
  86.  *                     FALSE, as if the user typed "Y" at
  87.  *                     every prompt.
  88.  *                     
  89.  *    <else>        No        Anything else the user types is
  90.  *                     considered a negative response.
  91.  *                    Return TRUE.
  92.  */
  93.  
  94. BOOL DontOverwriteExistingFile(char *filename)
  95. {
  96.     char buf[3];            /* Contains the user's response. */
  97.     static BOOL all    = FALSE;    /* User chose "A". */
  98.     BOOL safety    = TRUE;        /* Preserve the original file? */
  99.  
  100.     if (all)            /* Overwrite all files. */
  101.         return(FALSE);
  102.  
  103.     if (EXISTS(filename))
  104.     {
  105.         fprintf(stderr,
  106.              "File \"%s\" already exists.\nOVERWRITE it? [%s]: ",
  107.              filename, "Yes/No/All, RETURN=No");
  108.         fflush(stderr);
  109.  
  110.         if (fgets_and_flush(buf, 2, stdin))
  111.         {
  112.             buf[0] = toupper(buf[0]);
  113.  
  114.             if (CtrlcCheck())
  115.                 safety = TRUE;        /* Don't overwrite. */
  116.             else if (buf[0] == 'A')
  117.             {
  118.                 all = TRUE;
  119.                 safety = FALSE;        /* Overwrite ALL. */
  120.             }
  121.             else if (buf[0] == 'Y')
  122.                 safety = FALSE;        /* Overwrite one. */
  123.             else
  124.                 safety = TRUE;        /* Don't overwrite. */
  125.         }
  126.         else
  127.             safety = TRUE;        /* Could not read answer. */
  128.     }
  129.     else
  130.         safety = FALSE;            /* File doesn't exist. */
  131.  
  132.     if (safety)
  133.         fprintf(stderr, "%s not overwritten.\n\n", filename);
  134.  
  135.     return(safety);
  136. }
  137.  
  138.  
  139. /*
  140.  * This function solves a problem with reading input.
  141.  * When we read a line of input with fgets(), and the input line is too long,
  142.  * this function flushes all the unread input characters.
  143.  *
  144.  * Algorithm:    If fgets() read a newline, then there is no unread input.
  145.  *        If fgets() did NOT read a newline, grab characters until
  146.  *        a new line is found.
  147.  *
  148.  * "alreadyRead" is the buffer that the previous fgets() used.
  149.  */
  150.  
  151. char *fgets_and_flush(char *buf, int length, FILE *fp)
  152. {
  153.     if (!fgets(buf, length, fp))
  154.         return(NULL);
  155.  
  156.     else
  157.     {
  158.         if (*(buf + strlen(buf) - 1) != '\n')
  159.         {
  160.             int c;
  161.             while ((c = getc(fp)) != EOF && (c != '\n'))
  162.                 ;
  163.         }
  164.         return(buf);
  165.     }
  166. }
  167.  
  168.